package middlecontent.classload;

import org.junit.Test;

import java.io.*;

/**
 * @Author: fxy
 * @Date: 2022/04/06/8:06
 * @Description: 类的主动使用：
 * 使用该类时进行初始化 即执行该类的<clint>方法
 *
 * 1：new
 * 2: 反序列化使用
 * 3：子类使用
 */
public class ActiveUse1 {
    @Test
    public void t1(){
        C1 c1 = new C1();
    }

    @Test
    //序列化
    public void t2() {
        C1 c1 = new C1();
        ObjectOutputStream outputStream = null;
        try {
            outputStream = new ObjectOutputStream(new FileOutputStream("c1.dat"));
            outputStream.writeObject(c1);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    //反序列化
    public void t3() {
        ObjectInputStream inputStream = null;
        try {
            inputStream = new ObjectInputStream(new FileInputStream("c1.dat"));
            Object o = inputStream.readObject();

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 子类使用
     */
    @Test
    public void t4(){
        C1 c1 = new C1();
    }

    @Test
    public void t5(){
        //使用不需要初始化的静态常量不会初始化该类
        //System.out.println(C2.a3);


        //System.out.println(C2.a2);

        //使用子类的静态变量会初始化父类
        //System.out.println(C1.a1);

        //子类使用父类的静态变量不会初始化子类
        //System.out.println(C1.a2);

        //子类使用父类的静态常量不会初始化子类及父类
        //System.out.println(C1.a3);

        /*
        使用静态变量（不论是否赋值）就会初始化
         */
        //System.out.println(C1.a4);
        //System.out.println(C2.a4);
        //System.out.println(C1.a1);
    }

    @Test
    public void t6(){
        //接口在添加default方法之后，如果使用继承他的子类，那么接口会被初始化
        System.out.println(C1.a1);
    }

}
class  C1 extends C2 implements C3, Serializable{
    static int a1;
    static {
        System.out.println("初始化C1");
    }
}
class C2{
    static int a2 = 1;
    static final int a3 = 3;
    static int a4;
    static {
        System.out.println("初始化C2");
    }
}

interface C3{
    C4 c4 = new C4();
    public static final int a5 = 1;
    public static final int a6 = 0;
    public default void a(){
        System.out.println("接口C3default方法");
    }
}
class C4{
    static {
        System.out.println("初始化C4");
    }
}